class WebSocketManager {
  private ws: WebSocket | null = null
  private reconnectAttempts = 0
  private maxReconnectAttempts = 5
  private reconnectInterval = 3000 // 重连间隔3秒
  private heartbeatInterval: number | null = null // 修复 NodeJS.Timeout 类型
  private url: string = ''
  private token: string = ''


  // 连接WebSocket
  connect(url: string, token?: string) {
    this.url = url
    this.token = token || ''

    // 如果有token,添加到URL参数中
    const wsUrl = token ? `${url}` : url

    try {
      this.ws = new WebSocket(wsUrl)
      this.setupEventListeners()
    } catch (error) {
      console.error('WebSocket连接失败:', error)
      this.handleReconnect()
    }
  }

  // 设置事件监听器
  private setupEventListeners() {
    if (!this.ws) return

    // 连接建立
    this.ws.onopen = () => {
      console.log('WebSocket连接已建立')
      this.reconnectAttempts = 0
      this.startHeartbeat()
      // 可以在这里发送初始化消息
      this.send({ type: 'init', message: '连接建立' })
    }

    // 接收消息
    this.ws.onmessage = (event) => {
      try {
        const data = JSON.parse(event.data)
        this.handleMessage(data)
      } catch (error) {
        console.error('解析消息失败:', error)
      }
    }

    // 连接关闭
    this.ws.onclose = (event) => {
      console.log('WebSocket连接已关闭:', event.code, event.reason)
      this.stopHeartbeat()

      // 如果不是主动关闭,尝试重连
      if (event.code !== 1000) {
        this.handleReconnect()
      }
    }

    // 连接错误
    this.ws.onerror = (error) => {
      console.error('WebSocket连接错误:', error)
    }
  }

  // 处理接收到的消息
  private handleMessage(data: any) {
    console.log('收到消息:', data)

    // 根据消息类型处理
    switch (data.type) {
      case 'chat':
        // 处理聊天消息
        this.handleChatMessage(data)
        break

      case 'notification':
        // 处理通知消息
        this.handleNotificationMessage(data)
        break
      case 'private_message':
        // 处理私信消息,进行页面跳转
        this.handlePrivateMessage(data)
        break
      case 'heartbeat':
        // 处理心跳响应
        console.log('收到心跳响应')
        break
      case 'force_logout':
        // 处理强制登出消息
        this.handleForceLogout(data)
        break
      default:
        console.log('未知消息类型:', data.type)
    }
  }

  // 处理聊天消息
  private handleChatMessage(data: any) {
    // 使用mitt事件总线通知其他组件
    import('@/mitt').then(({ default: $bus }) => {
      $bus.emit('chat-message', data)
    })
  }

  // 处理通知消息
  private handleNotificationMessage(data: any) {
    // 使用mitt事件总线通知其他组件
    import('@/mitt').then(({ default: $bus }) => {
      $bus.emit('notification-message', data)
    })
  }

  // 处理私信消息,进行页面跳转
  private handlePrivateMessage(data: any) {
    console.log('收到私信消息:', data)

    // 检查是否有content字段
    if (data.content) {
      try {
        // 动态导入router
        import('@/router').then(({ default: router }) => {
          // 使用content作为跳转路径
          const targetPath = data.content
  
          console.log('准备跳转到:', targetPath)

          // 检查路径是否有效
          if (targetPath && typeof targetPath === 'string') {
            // 使用router.push进行页面跳转
       
              // 如果跳转失败,可以跳转到首页或其他页面
              if(targetPath === '/login') {
                console.warn('跳转到登录页面')
                // 这里可以添加额外的逻辑,比如清除用户信息等

                // 在需要时再获取 store 实例
                this.handleForceLogout(data)
               
              }else{
              router.push(targetPath)

              }
            
          } else {
            console.warn('无效的跳转路径:', targetPath)
          }
        })
      } catch (error) {
        console.error('处理私信消息失败:', error)
      }
    } else {
      console.warn('私信消息缺少content字段:', data)
    }
  }

  // 新增:处理强制登出消息
  private handleForceLogout(data: any) {
    console.log('收到强制登出指令:', data)

    // 使用 ElNotification 提示用户
    import('element-plus').then(({ ElNotification }) => {
      ElNotification({
        title: '系统通知',
        message: '您的账号已被管理员强制下线.',
        type: 'warning',
        duration: 5000,
      })
    })

    // 获取 user store 并执行登出操作
    import('@/store/modules/user').then(({ default: useUserStore }) => {
      const userStore = useUserStore()
      userStore.userLogout().then(() => {
        // 登出成功后,跳转到登录页
        // 这里的 window.location.reload() 可以确保整个应用状态重置,更彻底
        window.location.href = '/login'
      })
    })
  }

  // 发送消息
  send(data: any) {
    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
      // console.log(JSON.stringify(data),'JSON.stringify(data)');

      switch (data.message) {
        case '/home':
          this.ws.send("主页")
          break
        case '/acl/role':
          this.ws.send("操作页面")
          break
        default:
          this.ws.send(data.message)
          break
      }

    } else {
      console.error('WebSocket未连接,无法发送消息')
    }
  }

  // 发送聊天消息
  sendChatMessage(message: string) {
    console.log('发送聊天消息:', message);

    switch (message) {
      case '/home':
        this.send({
          type: 'chat',
          message: '主页',
          timestamp: Date.now(),
        })
        break
      case '/acl/role':
        this.send({
          type: 'chat',
          message: '操作页面',
          timestamp: Date.now(),
        })
        break
      default:
        this.send({
          type: 'chat',
          message,
          timestamp: Date.now(),
        })
        break
    }
    this.send({
      type: 'chat',
      message,
      timestamp: Date.now(),
    })
  }

  // 开始心跳
  private startHeartbeat() {
    this.heartbeatInterval = window.setInterval(() => {
      this.send({ type: 'heartbeat', timestamp: Date.now() })
    }, 30000) // 每30秒发送一次心跳
  }

  // 停止心跳
  private stopHeartbeat() {
    if (this.heartbeatInterval) {
      clearInterval(this.heartbeatInterval)
      this.heartbeatInterval = null
    }
  }

  // 处理重连
  private handleReconnect() {
    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
      console.error('WebSocket重连次数已达上限')
      return
    }

    this.reconnectAttempts++
    console.log(
      `尝试重连 (${this.reconnectAttempts}/${this.maxReconnectAttempts})`,
    )

    setTimeout(() => {
      this.connect(this.url, this.token)
    }, this.reconnectInterval)
  }

  // 关闭连接
  disconnect() {
    if (this.ws) {
      this.ws.close(1000, '主动关闭')
      this.ws = null
    }
    this.stopHeartbeat()
  }

  // 获取连接状态
  getState() {
    return this.ws ? this.ws.readyState : WebSocket.CLOSED
  }

  // 检查是否已连接
  isConnected(): boolean {
    return this.ws ? this.ws.readyState === WebSocket.OPEN : false
  }
}

// 创建单例实例
const wsManager = new WebSocketManager()

export default wsManager


